package com.rc.web.mapper;

import com.mybatisflex.core.BaseMapper;
import com.mybatisflex.core.paginate.Page;
import com.mybatisflex.core.query.QueryWrapper;
import com.mybatisflex.core.update.UpdateChain;
import com.rc.pojo.dto.comment.CommentPageQuery;
import com.rc.pojo.po.Comment;
import com.rc.pojo.vo.comment.CommentPageVO;

import java.util.List;

import static com.mybatisflex.core.query.QueryMethods.*;
import static com.rc.pojo.po.table.CommentTableDef.COMMENT;

/**
 * 评论表 映射层。
 * 提供评论相关的数据库操作接口
 */
public interface CommentMapper extends BaseMapper<Comment> {

    /**
     * 查询最新评论
     * @param size 查询数量
     * @param mapId 关联项ID
     * @param type 评论类型
     * @return 评论列表
     */
    default List<Comment> selectLast(int size,long mapId,int type){
        return selectListByQuery(QueryWrapper.create()
                .where(COMMENT.ITEM_ID.eq(mapId))
                .and(COMMENT.TYPE.eq(type))
                .orderBy(COMMENT.UPDATE_TIME.desc())
                .limit(size)
        );
    }

    /**
     * 计算平均评分
     * @param itemId 关联项ID
     * @param type 评论类型
     * @return 平均评分
     */
    default double selectScore(long itemId,int type){
        return selectOneByQueryAs(QueryWrapper.create()
                        .select(
                                round(ifNull(sum(COMMENT.SCORE).divide(count(COMMENT.ALL_COLUMNS)), number(0.0)))
                        )
                        .where(COMMENT.ITEM_ID.eq(itemId))
                        .and(COMMENT.TYPE.eq(type))
                ,double.class);
    }

    /**
     * 查找推荐人数
     * @param itemId 关联项ID
     * @param type 评论类型
     * @return 推荐人数
     */
    default int selectRecommended(long itemId,int type){
        return selectOneByQueryAs(QueryWrapper.create()
                        .select(
                                count(COMMENT.ALL_COLUMNS)
                        )
                        .where(COMMENT.ITEM_ID.eq(itemId))
                        .and(COMMENT.TYPE.eq(type))
                        .and(COMMENT.SCORE.ge(4))
                ,int.class);
    }

    /**
     * 根据类型查询评论列表
     * @param itemId 关联项ID
     * @param type 评论类型
     * @return 评论列表
     */
    default List<Comment> selectListByType(long itemId,int type){
        return selectListByQuery(QueryWrapper.create()
                .where(COMMENT.TYPE.eq(type))
                .and(COMMENT.ITEM_ID.eq(itemId)));
    }

    /**
     * 增加评论浏览量
     * @param id 评论ID
     */
    default void viewsAdd(long id){
        UpdateChain.of(this)
                .set(COMMENT.VIEWS,COMMENT.VIEWS.add(1))
                .where(COMMENT.ID.eq(id))
                .update();
    }

    /**
     * 根据关联项ID列表查询评论
     * @param itemIds 关联项ID列表
     * @param type 评论类型
     * @param score 最低评分
     * @return 评论列表
     */
    default List<Comment> selectByItemIds(List<Long> itemIds,int type,int score){
        QueryWrapper subquery = QueryWrapper.create()
                .select("*", "ROW_NUMBER() over (PARTITION by item_id ORDER BY create_time desc) as row_num")
                .from(COMMENT)
                .where(COMMENT.ITEM_ID.in(itemIds))
                .and(COMMENT.TYPE.eq(type))
                .and(COMMENT.SCORE.ge(score));

        return selectListByQuery(QueryWrapper.create()
                .from(subquery).as("t1")
                .where("row_num <= 3")
        );
    }

    /**
     * 根据用户ID更新评论
     * @param comment 评论实体
     */
    default void updateByConId(Comment comment){
        updateByQuery(comment,true,QueryWrapper.create()
                .where(COMMENT.CON_ID.eq(comment.getConId()))
        );
    }

    /**
     * 分页查询评论
     * @param dto 分页查询条件
     * @return 分页结果
     */
    default Page<CommentPageVO> selectPage(CommentPageQuery dto){
        Page<CommentPageVO> page = Page.of(dto.getCurrent(), dto.getPageSize());
        return paginateAs(page,QueryWrapper.create()
                .where(COMMENT.TYPE.eq(dto.getType()))
                ,CommentPageVO.class);
    }

    /**
     * 根据用户ID、关联项ID和类型查询评论
     * @param conId 用户ID
     * @param itemId 关联项ID
     * @param type 评论类型
     * @return 评论实体
     */
    default Comment selectByConIdAndItemIdAndType(long conId,long itemId,Integer type){
        return selectOneByQuery(QueryWrapper.create()
                .where(COMMENT.CON_ID.eq(conId))
                .and(COMMENT.ITEM_ID.eq(itemId))
                .and(COMMENT.TYPE.eq(type))
        );
    }
}
